home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / language / iconv8_e.arc / DOCS.ARC / TR90-6.DOC < prev    next >
Text File  |  1985-11-20  |  20KB  |  793 lines
  1.  
  2.  
  3.  
  4.  
  5.  
  6.  
  7.  
  8.  
  9.  
  10.  
  11.  
  12.  
  13.  
  14.                 An Overview of Version 8 the Icon
  15.                       Programming Language*
  16.  
  17.  
  18.                         Ralph E. Griswold
  19.  
  20.  
  21.  
  22.  
  23.                             TR 90-6a
  24.  
  25.  
  26.  
  27.  
  28.  
  29.  
  30.  
  31.  
  32.  
  33.  
  34.  
  35.  
  36.  
  37.  
  38.  
  39.  
  40.  
  41.  
  42.  
  43.  
  44.  
  45.  
  46.  
  47.  
  48.  
  49.          January 1, 1990; last revised February 13, 1990
  50.  
  51.  
  52.                  Department of Computer Science
  53.  
  54.                     The University of Arizona
  55.  
  56.                       Tucson, Arizona 85721
  57.  
  58.  
  59.  
  60.  
  61. *This work was supported by the National Science Foundation under
  62. Grant CCR-8713690.
  63.  
  64.  
  65.  
  66.  
  67.  
  68.  
  69.  
  70.  
  71.  
  72.  
  73.  
  74.  
  75.  
  76.                 An Overview of Version 8 the Icon
  77.                       Programming Language
  78.  
  79.  
  80.  
  81.  
  82. 1.__Introduction
  83.  
  84.    Icon is a high-level programming language with extensive
  85. facilities for processing strings and structures. Icon has
  86. several novel features, including expressions that may produce
  87. sequences of results, goal-directed evaluation that automatically
  88. searches for a successful result, and string scanning that allows
  89. operations on strings to be formulated at a high conceptual
  90. level.
  91.  
  92.    Icon emphasizes high-level string processing and a design phi-
  93. losophy that allows ease of programming and short, concise pro-
  94. grams. Storage allocation and garbage collection are automatic in
  95. Icon, and there are few restrictions on the sizes of objects.
  96. Strings, lists, and other structures are created during program
  97. execution and their size does not need to be known when a program
  98. is written.  Values are converted to expected types automati-
  99. cally; for example, numeral strings read in as input can be used
  100. in numerical computations without explicit conversion.  Icon has
  101. an expression-based syntax with reserved words; in appearance,
  102. Icon programs resemble those of Pascal and C.
  103.  
  104.    Although Icon has extensive facilities for processing strings
  105. and structures, it also has a full repertoire of computational
  106. facilities. It is suitable for a wide variety of applications.
  107. Some examples are:
  108.  
  109.      +  text analysis, editing, and formatting
  110.  
  111.      +  document formating
  112.  
  113.      +  artificial intelligence
  114.  
  115.      +  expert systems
  116.  
  117.      +  rapid prototyping
  118.  
  119.      +  symbolic mathematics
  120.  
  121.      +  text generation
  122.  
  123.      +  data laundry
  124.  
  125.    There are public-domain implementations of Icon for the Amiga,
  126. the Atari ST, the Macintosh under MPW, MS-DOS, MVS, OS/2, many
  127.  
  128.  
  129.  
  130.                               - 1 -
  131.  
  132.  
  133.  
  134.  
  135.  
  136.  
  137.  
  138.  
  139. UNIX systems, VM/CMS, and VMS. There also is a commercial imple-
  140. mentation of an enhanced version of Icon for the Macintosh [1].
  141.  
  142.    The remainder of this report briefly describes the highlights
  143. of Icon.  For a complete description, see [2,3].
  144.  
  145.  
  146. 2.__Expression_Evaluation
  147.  
  148. 2.1__Conditional_Expressions
  149.  
  150.    In Icon there are conditional expressions that may succeed and
  151. produce a result, or may fail and not produce any result. An
  152. example is the comparison operation
  153.  
  154.         i > j
  155.  
  156. which succeeds (and produces the value of j) provided that the
  157. value of i is greater than the value of j, but fails otherwise.
  158. Similarly,
  159.  
  160.         i > j > k
  161.  
  162. succeeds if the value of j is between i and k.
  163.  
  164.    The success or failure of conditional operations is used
  165. instead of Boolean values to drive control structures in Icon. An
  166. example is
  167.  
  168.         if i > j then k := i else k := j
  169.  
  170. which assigns the value of i to k if the value of i is greater
  171. than the value of j, but assigns the value of j to k otherwise.
  172.  
  173.    The usefulness of the concepts of success and failure is
  174. illustrated by find(s1,s2), which fails if s1 does not occur as a
  175. substring of s2.  Thus
  176.  
  177.         if i := find("or",line) then write(i)
  178.  
  179. writes the position at which "or" occurs in line, if it occurs,
  180. but does not write a value if it does not occur.
  181.  
  182.    Many expressions in Icon are conditional. An example is
  183. read(), which produces the next line from the input file, but
  184. fails when the end of the file is reached. The following expres-
  185. sion is typical of programming in Icon and illustrates the
  186. integration of conditional expressions and conventional control
  187. structures:
  188.  
  189.         while line := read() do
  190.            write(line)
  191.  
  192. This expression copies the input file to the output file.
  193.  
  194.  
  195.  
  196.                               - 2 -
  197.  
  198.  
  199.  
  200.  
  201.  
  202.  
  203.  
  204.  
  205.    If an argument of a function fails, the function is not
  206. called, and the function call fails as well. This ``inheritance''
  207. of failure allows the concise formulation of many programming
  208. tasks. Omitting the optional do clause in while-do, the previous
  209. expression can be rewritten as
  210.  
  211.         while write(read())
  212.  
  213.  
  214. 2.2__Generators
  215.  
  216.    In some situations, an expression may be capable of producing
  217. more than one result. Consider
  218.  
  219.         sentence := "Store it in the neighboring harbor"
  220.         find("or",sentence)
  221.  
  222. Here "or" occurs in sentence at positions 3, 23, and 33. Most
  223. programming languages treat this situation by selecting one of
  224. the positions, such as the first, as the result of the expres-
  225. sion. In Icon, such an expression is a generator and is capable
  226. of producing all three positions.
  227.  
  228.    The results that a generator produces depend on context. In a
  229. situation where only one result is needed, the first is produced,
  230. as in
  231.  
  232.         i := find("or",sentence)
  233.  
  234. which assigns the value 3 to i.
  235.  
  236.    If the result produced by a generator does not lead to the
  237. success of an enclosing expression, however, the generator is
  238. resumed to produce another value. An example is
  239.  
  240.         if (i := find("or",sentence)) > 5 then write(i)
  241.  
  242. Here the first result produced by the generator, 3, is assigned
  243. to i, but this value is not greater than 5 and the comparison
  244. operation fails. At this point, the generator is resumed and pro-
  245. duces the second position, 23, which is greater than 5. The com-
  246. parison operation then succeeds and the value 23 is written.
  247. Because of the inheritance of failure and the fact that com-
  248. parison operations return the value of their right argument, this
  249. expression can be written in the following more compact form:
  250.  
  251.         write(5 < find("or",sentence))
  252.  
  253.  
  254.    Goal-directed evaluation is inherent in the expression evalua-
  255. tion mechanism of Icon and can be used in arbitrarily complicated
  256. situations.  For example,
  257.  
  258.  
  259.  
  260.  
  261.  
  262.                               - 3 -
  263.  
  264.  
  265.  
  266.  
  267.  
  268.  
  269.  
  270.  
  271.         find("or",sentence1) = find("and",sentence2)
  272.  
  273. succeeds if "or" occurs in sentence1 at the same position as and
  274. occurs in sentence2.
  275.  
  276.    A generator can be resumed repeatedly to produce all its
  277. results by using the every-do control structure. An example is
  278.  
  279.         every i := find("or",sentence)
  280.            do write(i)
  281.  
  282. which writes all the positions at which "or" occurs in sentence.
  283. For the example above, these are 3, 23, and 33.
  284.  
  285.    Generation is inherited like failure, and this expression can
  286. be written more concisely by omitting the optional do clause:
  287.  
  288.         every write(find("or",sentence))
  289.  
  290.  
  291.    There are several built-in generators in Icon. One of the most
  292. frequently used of these is
  293.  
  294.         i to j
  295.  
  296. which generates the integers from i to j. This generator can be
  297. combined with every-do to formulate the traditional for-style
  298. control structure:
  299.  
  300.         every k := i to j do
  301.            f(k)
  302.  
  303. Note that this expression can be written more compactly as
  304.  
  305.         every f(i to j)
  306.  
  307.  
  308.    There are a number of other control structures related to gen-
  309. eration.  One is alternation,
  310.  
  311.         expr1 | expr2
  312.  
  313. which generates the results of expr1 followed by the results of
  314. expr2.  Thus
  315.  
  316.         every write(find("or",sentence1) | find("or",sentence2))
  317.  
  318. writes the positions of "or" in sentence1 followed by the posi-
  319. tions of "or" in sentence2. Again, this sentence can be written
  320. more compactly by using alternation in the second argument of
  321. find():
  322.  
  323.         every write(find("or",sentence1 | sentence2))
  324.  
  325.  
  326.  
  327.  
  328.                               - 4 -
  329.  
  330.  
  331.  
  332.  
  333.  
  334.  
  335.  
  336.  
  337.    Another use of alternation is illustrated by
  338.  
  339.         (i | j | k) = (0 | 1)
  340.  
  341. which succeeds if any of i, j, or k has the value 0 or 1.
  342.  
  343.    Procedures can be used to add